# %% [markdown]
# 
# 完成作业：
# 1. 请写出列表支持的所有方法及说明（例如: append 向列表末尾添加元素）
# 
# 1A: append 末尾追加，remove 删除元素，insert 插入元素，reverse 翻转，index 检索，split 分割，count 技术，len 计算长度，clear清除所有元素，pop 弹出最后一个元素，extend 在末尾追加列表，sort 排序，copy 浅拷贝，deepcopy 深拷贝
# 
# 2. 说明列表的浅拷贝和深拷贝的区别
# 
# 2A：浅拷贝 指创建新的数据，有原始数据属性值的一份精确拷贝，如果是原始数据是基本类型，则拷贝基本类型，如果原始数据是引用类型，则拷贝引用地址，深层次的引用共享内存地址
#     深拷贝 会开辟一个新的栈，两个对象属性完全相同，但是对应不同的地址
#     *基本类型与引用类型的存储方式：
#     基本类型：基本类型只需要一段单独的内存，用于存储实际的数据。
#     引用类型：引用类型需要两段内存，第一段存储实际的数据，它总是位于堆中。第二段是一个引用，指向数据在堆中的存放位置。
# 
# 3. 说明列表和元组的相同点和不同点
# 
# 3A：
#     相同点：
#     1. 列表和元组都属于线性结构中的顺序表，是有序序列
#     2. 都支持使用双向索引访问其中的元素
#     3. 可以使用count/index/len/map/filter等内置函数，+，*，in运算符也可以作用于列表和元组
#     不同点：
#     1. 列表是可变序列，元组是不可变序列
# 

# %%
x1 = ['a',3]
y1 = (1,'c')

x2 = ['a',3,1]
y2 = (2,3,4)
y3 = (2,)

print(x1*3)
print(y1*3)

print(x1 + x2)
print(y1 + y2)

for i in x1:
    print(i)

# %%
# 4. 请写出字符串支持的所有方法及说明（例如: lower 返回字符串的小写）
s1 = '\t abc\n \r a bs abc dc\t\n'
# str.count()
# print(s1)
# print(s1[2],s1[5])
# print(s1.count('abc'))
# print(s1.count('abc', 2, 5))

# str.endswith()
# print(s1.endswith('\n',2, 6))

# str.find() and str.index()
# str.rfind() and str.rindex()
#返回子字符串sub在str切片中被找到的最小索引， 未找到返回-1 vs str.index()未找到返回ValueError
# print(s1.find('a', 2, 5)) #仍然返回2 虽然从2开始找，返回str中索引号

# str.format()

# 以下针对str判断均返回bool值
# str.isalnum()，str.isalpha(), str.isascii(), str.isdecimal(), str.isdigit(), str.isidentifier(),str.islower(), str.isnumeric(), str.isupper()
# print('000'.isdecimal())
# print('0002'.isdigit())
# print('20.2'.isnumeric())
# print(s1.isascii())
# print('_abz10'.isidentifier())

# str.join(iterable) # str作为iterable元素之间的分割

a = 'abc'
b = ['4','1','3']
c = ('1','3','4')

# a.join(b)
# print(a)
# print(a.join(b))
# print(a.join(c))
# 'ab'.join(['1','2'])

# str.lower() 返回源字符串的副本，所有区分大小写的字符均转换成小写
# str.upper()

# str.partition(sep) 在sep首次出现的位置拆分字符串，返回一个3元组
print(a.upper().partition('A'))
print(a.upper().partition('a'))
print(a.upper().rpartition('a'))

# str.removeprefix(prefix) 返回原始字符串副本
# str.removesuffix(suffix)
s = '"POST'
# print(s.removeprefix('"'))
# print(s)
# print(s[len('"'):])

# str.replace(old, new[, count]) 返回str副本
# s1.replace('a','A',2)
# print(s1)

#


# %%
# 4. 请写出字符串支持的所有方法及说明（例如: lower 返回字符串的小写）
s1 = '\t abc\n \r a bs abc dc\t\n'
# str.count()
# print(s1)
# print(s1[2],s1[5])
# print(s1.count('abc'))
# print(s1.count('abc', 2, 5))

# str.endswith()
# str.startswith()
# print(s1.endswith('\n',2, 6))

# str.find() and str.index()
# str.rfind() and str.rindex()
#返回子字符串sub在str切片中被找到的最小索引， 未找到返回-1 vs str.index()未找到返回ValueError
# print(s1.find('a', 2, 5)) #仍然返回2 虽然从2开始找，返回str中索引号

# str.format()

# 以下针对str判断均返回bool值
# str.isalnum()，str.isalpha(), str.isascii(), str.isdecimal(), str.isdigit(), str.isidentifier(),str.islower(), str.isnumeric(), str.isupper()
# print('000'.isdecimal())
# print('0002'.isdigit())
# print('20.2'.isnumeric())
# print(s1.isascii())
# print('_abz10'.isidentifier())

# str.join(iterable) # str作为iterable元素之间的分割

a = 'abc'
b = ['4','1','3']
c = ('1','3','4')

# a.join(b)
# print(a)
# print(a.join(b))
# print(a.join(c))
# 'ab'.join(['1','2'])

# str.lower() 返回源字符串的副本，所有区分大小写的字符均转换成小写
# str.upper()
# str.swapcase() 返回副本，大小写转换

# str.partition(sep) 在sep首次出现的位置拆分字符串，返回一个3元组
# print(a.upper().partition('A'))
# print(a.upper().rpartition('A'))
# print(a.upper().partition('a'))
# print(a.upper().rpartition('a'))

# str.removeprefix(prefix) 返回原始字符串副本
# str.removesuffix(suffix)
s = '"POST'
# print(s.removeprefix('"'))
# print(s)
# print(s[len('"'):])

# str.replace(old, new[, count]) 返回str副本
# s1.replace('a','A',2)
# print(s1)

# str.split(sep=None, maxsplit=- 1)
# str.rsplit(sep=None, maxsplit=- 1)
# print('abc  dfsdvs   bsfs'.split('b'))
# print('12 3'.split('2'))
# print('abcdfsdvsbsfs'.rsplit('b'))
# print('abcdfsdvsbsfs'.split('b', 1))
# print('abcdfsdvsbsfs'.rsplit('b', 1))

# # str.splitlines(keepends=False)
# print('ab c\n\nde fg\rkl\r\n'.splitlines())
# print('ab c\n\nde fg\rkl\r\n'.splitlines(1))

# str.strip([chars]) 返回str副本
# '   spacio  us   '.strip()
# print('www.example.com'.strip('cmowz.'))
# print('www.example.com'.rstrip('cmowz.'))
# print('www.example.com'.lstrip('cmowz.'))

# print('www.example.com'.strip('cmowz.'), \
# 'www.example.com'.rstrip('cmowz.'), \
# 'www.example.com'.lstrip('cmowz.'))

# str.ljust()  返回副本
a = 'abc'
a.ljust(5,'*')
a.rjust(6,'*')
print(a)

# %%
""" 5. 有如下一个字符串变量logs，请统计出每种请求类型的数量（提示：空格分割的第2列是请求类型），得到如下输出：
POST 2
GET 3

下边是logs变量：
logs = '''
111.30.144.7 "POST /mock/login/?t=GET HTTP/1.1" 200 
111.30.144.7 "Get /mock/users/?t=POST HTTP/1.1" 200 
111.13.100.92 "Post /mock/login/ HTTP/1.1" 200 
223.88.60.88 "GET /mock/users/?t=POST HTTP/1.1" 200 
111.30.144.7 "GET /mock/users/ HTTP/1.1" 200 
''' """

logs = '''
111.30.144.7 "POST /mock/login/?t=GET HTTP/1.1" 200 
111.30.144.7 "Get /mock/users/?t=POST HTTP/1.1" 200 
111.13.100.92 "Post /mock/login/ HTTP/1.1" 200 
223.88.60.88 "GET /mock/users/?t=POST HTTP/1.1" 200 
111.30.144.7 "GET /mock/users/ HTTP/1.1" 200 
'''

r = logs.split('\n')
j = 0
c = []
n_p = 0
n_g = 0

for i in range(1,len(r)-1):
    c.append(r[i].split(' ',2))
    
    c[j][1] = c[j][1].upper()
    # print(c[j])
    
    if c[j][1] == '\"POST': n_p = n_p + 1
    if c[j][1] == '\"GET' : n_g = n_g + 1
    j = j + 1

print('POST {}'.format(n_p))
print('GET {}'.format(n_g))
